
import java.util.*;

/**
 * Die Klasse <code><b>StEdit.java</b></code> enthaelt Hilfsmethoden fuer die Realisierung
 * von typischen Texteditorfunktionen.
 * Grundkonzept dieser Klasse ist die Speicherung eines kommpletten Textes
 * mit mehreren Zeilen in einer Zeichenkette. Die Zeilenwechsel sind durch
 * das Zeichen <code>'/n'</code> kodiert, so dass der Text mit <code>System.out.println(text)</code>
 * ausgegeben werden kann.
 * @author rla
 * @version 1.8 Aufgabenstellung
 */
public class StEdit {

    private StEdit() {
    } // Es gibt keinen Konstruktor
    /**
     * Trennzeichen fuer Spalten.
     * Muss sich von den anderen Separatorzeichen und dem '.' unterscheiden!
     * Darf kein Steuerzeichen fuer regulaere Ausdruecke von split enthalten!
     */
    public static char columnSeparator;
    /**
     * Trennzeichen fuer Zeilen.
     * Muss sich von den anderen Separatorzeichen und dem '.' unterscheiden!
     * Darf kein Steuerzeichen fuer regulaere Ausdruecke von split enthalten!
     */
    public static char rowSeparator;

    /**
     * Initialisierung der Klasse
     */
    static {
        columnSeparator = ';';
        rowSeparator = '\n';
    }

    /**
     * Ersetzt in der Zeichenkette <b>s</b>, ab der Position <b>start</b> die erste Zeichenkette <b>su</b> durch <b>se</b>.<br>
     * <br><b>Anwendungsbeispiel:</b><PRE>
     * ...
     * String s     = "abcabcabc";
     * int    start = 1
     * String su    = "ab";
     * String se    = "AB";
     * String sret  = ersetzen( s, start, su, se);
     * ...</PRE>
     * liefert das Ergebnis <CODE>sret = "abcABcabc"</CODE>.<br><br>
     * Wenn die gesuchte Zeichenkette nicht gefunden wird, den Wert null hat oder andere
     * Parameter unsinnig sind wird s direkt zurueckgegeben.
     * @param s Ausgangszeichenkette
     * @param start Position ab der nach su in s gesucht wird
     * @param su Zeichenkette nach der gesucht wird
     * @param se Zeichenkette die su ersetzen soll
     * @return Zeichenkette in der su durch se ersetzt ist
     */
    public static String ersetzen(String s, int start, String su, String se) {
        //ohne Suchwort (bzw. 0 zeichen lang) oder zu ersetzendes Wort wird das Orginal Wort wiedergegeben
        if (su == null || se == null || s == null || su.length() <= 0 || start < 0) {
            return s;
        }
        StringBuilder temp = new StringBuilder(s);
        //Sucht nach erster Position des Wortes, von Position Start
        int pos = temp.indexOf(su, start);
        //Wenn Wort nicht Existent, dann gibt er das Orginale Worte wieder
        if (pos < 0) {
            return s;
        }
        //Wenn das Wort Existent ist, dann ersetzt er es
        temp.replace(pos, pos + su.length(), se);
        return temp.toString();
    }

    /**
     * Ersetzt in der Zeichenkette <b>s</b>, ab der Position <b>start</b> alle Vorkommen der Zeichenkette <b>su</b>
     * durch <b>se</b>.<br>
     * <br><b>Anwendungsbeispiel:</b><PRE>
     * ...
     * String s     = "abcabcabc";
     * int    start = 2
     * String su    = "ab";
     * String se    = "AB";
     * String sret  = ersetzen( s, start, su, se);
     * ...</PRE>
     * liefert das Ergebnis <CODE>sret = "abcABcABc"</CODE>.<br><br>
     * Wenn die gesuchte Zeichenkette nicht gefunden wird, den Wert null hat oder andere
     * Parameter unsinnig sind wird s direkt zurueckgegeben.
     * @param s Ausgangszeichenkette
     * @param start Position ab der nach su in s gesucht wird
     * @param su Zeichenkette nach der gesucht wird
     * @param se Zeichenkette die su ersetzen soll
     * @return Zeichenkette in der su durch se ersetzt ist
     */
    public static String allesErsetzen(String s, int start, String su, String se) {
        //ohne Suchwort oder zu ersetzendes Wort oder 0 zeichen lang, wird das Orginal Wort wiedergegeben
        if (su == null || se == null || s == null || su.length() <= 0 || start < 0) {
            return s;
        }
        if (se.equals(su)) {
            return s;
        }
        StringBuilder temp = new StringBuilder(s);
        int pos = temp.indexOf(su, start);
        if (pos < 0) {
            return s;
        }
        while (pos != -1) {
            temp.replace(pos, pos + su.length(), se);
            pos = temp.indexOf(su, pos + se.length());
        }
        return temp.toString();
    }

    /**
     * Berechnet die Zeilennummer einer Zeichenposition <b>p</b> in der Zeichenkette <b>s</b>.<br>
     * <br><b>Anwendungsbeispiel:</b><PRE>
     * ...
     * // Zeichenposition:    1      |  2          3
     * //          0123456789 01234567890 1234567890123
     * String s = "1. Zeile \n 2. Zeile \n letzte Zeile";
     * int    p = 17
     * int zret = zeilenNummer( s, p);
     * ...</PRE>
     * liefert das Ergebnis <CODE>zret = 2</CODE>.<br><br>
     * Wenn s nicht initialisiert oder p negativ ist, dann soll 0
     * zurueckgegeben werden.<br>
     * Wenn p ausserhalb von s liegt, dann wird die Nummer der letzten
     * Zeile von s zurueckgegeben.
     * @param s Zeichenkette (Zeilenwechsel mit \n kodiert)
     * @param p Position eines Zeichens in s, dessen Zeilennummer gesucht wird
     * @return Zeilennummer des Zeichens auf Position p
     */
    public static int zeilenNummer(String s, int p) {
        StringBuffer temp = new StringBuffer(s);
        char umbruch = '\n';
        int zret = 1;
        for (int i = 0; i < p; i++) {
            if (temp.charAt(i) == umbruch) {
                zret++;
            }
        }
        return zret;
    }

    /**
     * @param s Haupttext der in Zeilen geteilt werden soll
     * @return gibt ein Array mit Text der jeweiligen Zeile wieder
     */
    public static ArrayList text_cutter(String s) {
        ArrayList<String> cutted_words = new ArrayList<String>();
        s.trim();
        String[] words = s.split("\n");
        for (int i = 0; i < words.length; i++) {
            cutted_words.add(words[i]);
        }
        return cutted_words;
    }

    /**
     * @param s Haupttext der in Worte geteilt werden soll
     * @return intwert mit anzahl von Wörtern
     */
    public static int count_words(String s) {
        StringBuffer temp_s = new StringBuffer(s);
        while (temp_s.indexOf("\n") != -1) {
            temp_s.replace(temp_s.indexOf("\n"), temp_s.indexOf("\n") + "\n".length(), " ");
        }
        ArrayList<String> cutted_words = new ArrayList<String>();
        String[] words = temp_s.toString().split(" ");
        for (int i = 0; i < words.length; i++) {
            if (words[i].length() >= 2) {
                cutted_words.add(words[i]);
            }
        }
        return cutted_words.size();
    }

    /**
     * @param start_pos_sel Anfang der Mausmakierung
     * @param end_pos_sel Ende der Mausmakierung
     * @param temp_text2 Gesamter Text
     * @param edited_text2 Gesamter Text
     * @return Nummeriert die Makierten Zeilen, Leere Zeilen werden nicht makiert
     */
    public static String num_help(int start_pos_sel, int end_pos_sel, String temp_text2) {
        StringBuffer temp_text = new StringBuffer(temp_text2); //Text
        StringBuffer edited_text = new StringBuffer(temp_text2); //Text
        temp_text.replace(end_pos_sel, temp_text.length(), ""); //löscht im temp_text den nicht makierten bereich
        temp_text.replace(0, start_pos_sel, ""); //löscht im temp_text den nicht makierten bereich
        ArrayList temp_cutted_text = new ArrayList(StEdit.text_cutter(temp_text.toString())); //Array mit Zerteilten Text
        int zahl = 1; //Nummerierungszahl
        //Komplizierte schleife mit if & else für die Nummerierung inkl. Fehler abfang
        for (int i = 0; i < temp_cutted_text.size(); i++) {
            if (temp_cutted_text.get(i).toString().length() >= 1) {
                if (i == 0) {
                    temp_cutted_text.set(i, zahl++ + ". " + temp_cutted_text.get(i).toString());
                } else {
                    temp_cutted_text.set(i, "\n" + zahl++ + ". " + temp_cutted_text.get(i).toString());
                }
            } else {
                if (i == 0) {
                } else {
                    temp_cutted_text.set(i, "\n");
                }

            }
        }
        String last_temp = ""; // temp
        //Schleife für wieder einführung des Textes mit Nummerierung in temp_text
        for (int l = 0; l < temp_cutted_text.size(); l++) {
            last_temp += temp_cutted_text.get(l);
        }
        edited_text.replace(start_pos_sel, end_pos_sel, last_temp); //setzt temp_text in makierten bereich in edited_text
        return edited_text.toString();
    }

    /*public static List open_help() {
    int z;
    List output_list = new ArrayList(3);
    StringBuffer temp_text = new StringBuffer("");
    JFileChooser chooser = new JFileChooser();
    chooser.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
    if (JFileChooser.APPROVE_OPTION == chooser.showDialog(null, "Öffnen")) {
    File dir = chooser.getSelectedFile();
    try {
    FileInputStream get_file = new FileInputStream(dir);
    try {
    while ((z = get_file.read()) != -1) {
    temp_text.append((char) z);
    }
    } catch (IOException ex) {
    output_list.add(1, "Beim Einlesen der Datei ist ein Fehler aufgetetten. Code: " + ex);
    }
    output_list.add(0, temp_text.toString());
    } catch (FileNotFoundException ex) {
    output_list.add(1, "" + ex);
    }
    }
    return output_list;
    }

    //Gibt ein Array wieder, mit der Position des jeiligen Zeilenanfangs
    public static ArrayList row_pos(String s, int p) {
    StringBuffer temp = new StringBuffer(s);
    char umbruch = '\n';
    int zahl = 0;
    ArrayList row_pos = new ArrayList();
    for (int i = 0; i < p; i++) {
    if (temp.charAt(i) == umbruch) {
    zahl = i;
    zahl++;
    row_pos.add(zahl);
    }
    }
    return row_pos;
    }*/
}

